/*
    * Copyright (C) 2011 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.base;
  
  import static com.google.common.base.Preconditions.checkNotNull;
  
  import com.google.common.annotations.Beta;
  import com.google.common.annotations.GwtCompatible;
  import com.google.common.annotations.GwtIncompatible;
  
  import java.io.Serializable;
  import java.lang.ref.WeakReference;
  import java.lang.reflect.Field;
  import java.util.EnumSet;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.WeakHashMap;
  
  import javax.annotation.Nullable;
  
  /**
   * Utility methods for working with {@link Enum} instances.
   *
   * @author Steve McKay
   *
   * @since 9.0
   */
  @GwtCompatible(emulated = true)
  @Beta
  public final class Enums {
  
    private Enums() {}
  
    /**
     * Returns the {@link Field} in which {@code enumValue} is defined. For example, to get the
     * {@code Description} annotation on the {@code GOLF} constant of enum {@code Sport}, use
     * {@code Enums.getField(Sport.GOLF).getAnnotation(Description.class)}.
     *
     * @since 12.0
     */
    @GwtIncompatible("reflection")
    public static Field getField(Enum<?> enumValue) {
      Class<?> clazz = enumValue.getDeclaringClass();
      try {
        return clazz.getDeclaredField(enumValue.name());
      } catch (NoSuchFieldException impossible) {
        throw new AssertionError(impossible);
      }
    }
  
    /**
     * Returns an optional enum constant for the given type, using {@link Enum#valueOf}. If the
     * constant does not exist, {@link Optional#absent} is returned. A common use case is for parsing
     * user input or falling back to a default enum constant. For example,
     * {@code Enums.getIfPresent(Country.class, countryInput).or(Country.DEFAULT);}
     *
     * @since 12.0
     */
    public static <T extends Enum<T>> Optional<T> getIfPresent(
        Class<T> enumClass, String value) {
      checkNotNull(enumClass);
      checkNotNull(value);
      return Platform.getEnumIfPresent(enumClass, value);
    }
  
    @GwtIncompatible("java.lang.ref.WeakReference")
    private static final Map<Class<? extends Enum<?>>, Map<String, WeakReference<? extends Enum<?>>>>
        enumConstantCache = new WeakHashMap
                <Class<? extends Enum<?>>, Map<String, WeakReference<? extends Enum<?>>>>();
  
    @GwtIncompatible("java.lang.ref.WeakReference")
    private static <T extends Enum<T>> Map<String, WeakReference<? extends Enum<?>>> populateCache(
        Class<T> enumClass) {
      Map<String, WeakReference<? extends Enum<?>>> result
          = new HashMap<String, WeakReference<? extends Enum<?>>>();
      for (T enumInstance : EnumSet.allOf(enumClass)) {
        result.put(enumInstance.name(), new WeakReference<Enum<?>>(enumInstance));
      }
      enumConstantCache.put(enumClass, result);
      return result;
    }
  
    @GwtIncompatible("java.lang.ref.WeakReference")
    static <T extends Enum<T>> Map<String, WeakReference<? extends Enum<?>>> getEnumConstants(
        Class<T> enumClass) {
     synchronized (enumConstantCache) {
       Map<String, WeakReference<? extends Enum<?>>> constants =
           enumConstantCache.get(enumClass);
       if (constants == null) {
         constants = populateCache(enumClass);
       }
       return constants;
     }
   }
 
   /**
    * Returns a converter that converts between strings and {@code enum} values of type
    * {@code enumClass} using {@link Enum#valueOf(Class, String)} and {@link Enum#name()}. The
    * converter will throw an {@code IllegalArgumentException} if the argument is not the name of
    * any enum constant in the specified enum.
    *
    * @since 16.0
    */
   public static <T extends Enum<T>> Converter<String, T> stringConverter(final Class<T> enumClass) {
     return new StringConverter<T>(enumClass);
   }
 
   private static final class StringConverter<T extends Enum<T>>
       extends Converter<String, T> implements Serializable {
 
     private final Class<T> enumClass;
 
     StringConverter(Class<T> enumClass) {
       this.enumClass = checkNotNull(enumClass);
     }
 
     @Override
     protected T doForward(String value) {
       return Enum.valueOf(enumClass, value);
     }
 
     @Override
     protected String doBackward(T enumValue) {
       return enumValue.name();
     }
 
     @Override
     public boolean equals(@Nullable Object object) {
       if (object instanceof StringConverter) {
         StringConverter<?> that = (StringConverter<?>) object;
         return this.enumClass.equals(that.enumClass);
       }
       return false;
     }
 
     @Override
     public int hashCode() {
       return enumClass.hashCode();
     }
 
     @Override
     public String toString() {
       return "Enums.stringConverter(" + enumClass.getName() + ".class)";
     }
 
     private static final long serialVersionUID = 0L;
   }
 }